package com.example.interviewassistant;

import android.util.Log;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 简历数据脱敏工具类
 * 用于处理简历中的敏感信息脱敏，如姓名、手机号、地址、证件号等
 */
public class SensitiveDataMask {
    private static final String TAG = "SensitiveDataMask";

    // 匹配中国大陆手机号的正则表达式
    private static final String MOBILE_PATTERN = "(1[3-9]\\d{9})";
    
    // 匹配中国大陆身份证号的正则表达式（支持15位和18位）
    private static final String ID_CARD_PATTERN = 
            "([1-9]\\d{5}(19|20)\\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])\\d{3}[0-9Xx])|" + 
            "([1-9]\\d{5}\\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])\\d{3})";
    
    // 匹配电子邮箱的正则表达式
    private static final String EMAIL_PATTERN = "([\\w.-]+@[\\w.-]+\\.[a-zA-Z]{2,})";
    
    // 匹配中文姓名的正则表达式（2-4个汉字）
    private static final String NAME_PATTERN = "(?<=[^\\u4e00-\\u9fa5]|^)([\u4e00-\u9fa5]{2,4})(?=[^\\u4e00-\\u9fa5]|$)";
    
    // 匹配地址的正则表达式（简单版，匹配常见的地址格式）
    private static final String ADDRESS_PATTERN = "(?<=[^\\u4e00-\\u9fa5]|^)([\u4e00-\u9fa5]{2,}?(?:省|市|自治区|自治州|县|区|镇|乡|街道|路|村|弄|号|室)[\u4e00-\u9fa5\\d\\s]{2,}?)(?=[^\\u4e00-\\u9fa5]|$)";

    /**
     * 对简历文本进行脱敏处理
     * @param resumeText 原始简历文本
     * @return 脱敏后的简历文本
     */
    public static String maskSensitiveInfo(String resumeText) {
        if (resumeText == null || resumeText.isEmpty()) {
            return resumeText;
        }
        
        try {
            // 依次处理各类敏感信息
            String maskedText = resumeText;
            maskedText = maskPattern(maskedText, MOBILE_PATTERN, 3, 4); // 手机号，保留前3位和后4位
            maskedText = maskPattern(maskedText, ID_CARD_PATTERN, 4, 4); // 身份证号，保留前4位和后4位
            maskedText = maskPattern(maskedText, EMAIL_PATTERN, 1, 0); // 邮箱，只保留@之前的第一个字符
            maskedText = maskPattern(maskedText, NAME_PATTERN, 1, 0); // 中文姓名，只保留第一个字
            maskedText = maskPattern(maskedText, ADDRESS_PATTERN, 6, 0); // 地址，只保留前6个字符
            
            return maskedText;
        } catch (Exception e) {
            Log.e(TAG, "Error masking sensitive data", e);
            // 如果脱敏过程中出错，为安全起见，返回原文本
            return resumeText;
        }
    }
    
    /**
     * 对匹配特定模式的字符串进行脱敏
     * @param text 原始文本
     * @param patternStr 要匹配的正则表达式模式
     * @param prefixNoMaskLen 前缀保留长度（不脱敏）
     * @param suffixNoMaskLen 后缀保留长度（不脱敏）
     * @return 脱敏后的文本
     */
    private static String maskPattern(String text, String patternStr, int prefixNoMaskLen, int suffixNoMaskLen) {
        Pattern pattern = Pattern.compile(patternStr);
        Matcher matcher = pattern.matcher(text);
        StringBuffer sb = new StringBuffer();
        
        while (matcher.find()) {
            String original = matcher.group(1);
            String masked = maskString(original, prefixNoMaskLen, suffixNoMaskLen);
            matcher.appendReplacement(sb, Matcher.quoteReplacement(masked));
        }
        matcher.appendTail(sb);
        
        return sb.toString();
    }
    
    /**
     * 对字符串进行脱敏处理
     * @param str 原始字符串
     * @param prefixNoMaskLen 前缀保留长度（不脱敏）
     * @param suffixNoMaskLen 后缀保留长度（不脱敏）
     * @return 脱敏后的字符串
     */
    private static String maskString(String str, int prefixNoMaskLen, int suffixNoMaskLen) {
        if (str == null || str.isEmpty()) {
            return str;
        }
        
        int length = str.length();
        
        // 处理边界情况
        if (prefixNoMaskLen >= length) {
            return str;
        }
        if (prefixNoMaskLen + suffixNoMaskLen >= length) {
            suffixNoMaskLen = length - prefixNoMaskLen;
        }
        
        // 计算需要被掩码的字符数量
        int maskLen = length - prefixNoMaskLen - suffixNoMaskLen;
        
        // 构建掩码替换字符串
        StringBuilder maskBuilder = new StringBuilder();
        for (int i = 0; i < maskLen; i++) {
            maskBuilder.append('*');
        }
        
        // 组合最终结果
        return str.substring(0, prefixNoMaskLen) + 
               maskBuilder.toString() + 
               (suffixNoMaskLen > 0 ? str.substring(length - suffixNoMaskLen) : "");
    }
} 